import java.lang.reflect.Array;
import java.util.Arrays;

public class test1 {
    //要求：把数组扩大两倍
    public static int[] func1(int[] array){
//                返回值           参数

//        在C语言中，不可以将数组作为返回值，哪怕这个数组是动态开辟出来的，但是在Java中可以

        int[] ret=new int[array.length];//在C语言中[]里一定要是数组，但是在Java中，可以是变量
        for (int i = 0; i < array.length; i++) {
            ret[i]=array[i]*2;
        }
        return ret;
    }

    public static void main(String[] args) {
        int[] array={1,2,3,4,5};
        int[] ret=func1(array);
        System.out.println(Arrays.toString(array));
//        从array的打印结果可以看出，扩大两倍，并不是在原数组中扩大两倍，而是把扩大两倍的值，放进一个新的数组中
        System.out.println(Arrays.toString(ret));
    }
    public static void main13(String[] args) {
        int[] array1=new int[2];
        int[] array2=null;//不指向任何对象
        System.out.println(array1.length);
        System.out.println(array2.length);
//        总结:如果将来代码 报错空指针异常，呢么我们
//        要做的是找到这行代码中的引用。判断这个引
//        用为什么是空的!!
    }
    public static void main12(String[] args) {
        int[] array1=new int[3];
        array1[0]=10;
        array1[1]=20;
        array1[2]=30;

        int[] array2=new int[]{1,2,3,4,5};
        array2[0]=100;
        array2[1]=200;

        array1=array2;
        //array1这个引用，指向array2这个引用所指对象
        array1[2]=300;
        array1[3]=400;
        array1[4]=500;

//        当2个引用同时指向一个对象的时候，通过任何一个引用都能修改这个对象的值
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i]);
        }
//        最担心的是，当两个引用同时指向一个对象时，如果操作了其中一个对象，就有可能改变另一个引用访问这个对象的值
    }
    public static void main11(String[] args) {
        int a=10;
        int b=20;
        int[] arr=new int[]{1,2,3};
//        在上述代码中，a、b、arr，都是函数内部的变量，因此其空间都在main方法对应的栈帧中分配。
//        a、b是内置类型的变量，因此其空间中保存的就是给该变量初始化的值。
//        array是数组类型的引用变量，其内部保存的内容可以简单理解成是数组在堆空间中的首地址。
//        引用变量并不直接存储对象本身，可以简单理解成存储的是对象在堆中空间的起始地址。通过该
//        地址，引用变量便可以去操作对象。有点类似C语言中的指针，但是Java中引用要比指针的操作更简单。
    }
    public static void main10(String[] args) {
        int[] array={1,2,3,4,5,6};
        String ret=Arrays.toString(array);
        System.out.println(ret);
        System.out.println(array);
        String str="hello";
        System.out.println(str);
//        基本数据类型创建的变量，称为基本变量，该变量空间中直接存放的是其所对应的值;
//        而引用数据类型创建的变量，一般称为对象的引用，其空间中存储的是对象所在空间的地址
        int a=10;
//        &a;//err
    }
    public static int max2(int a,int b){
        return a>b?a:b;
    }

    public  static  int max3(int a,int b,int c){
        int max=max2(a,b);
        int ret=max2(max,c);
        return ret;
    }
    public  static int max4(int a,int b,int c){
        int ret=a>b?a:b;
        int max=ret>c?ret:c;
        return max;
    }
    public static  int add(int a, int b){
        return  a+b;
    }
    public  static  double add(double a,double b, double c){
        return a+b+c;
    }

    public static void main9(String[] args) {
        System.out.println(add(1,2));
        System.out.println(add(1.2,2.6,9.4));
    }
    public static void main8(String[] args) {
        System.out.println(max3(1,2,3));
        System.out.println(max3(4,5,6));
    }
    public static void main7(String[] args) {
        int[] array={1,2,3,4,5,6};
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
        System.out.println();
//        另一种遍历方法,无法获取对应的下标
        for (int x:array) {
            System.out.print(x+" ");
        }
//        第三种遍历方法
        System.out.println();
        String ret=Arrays.toString(array);
        System.out.println(ret);
//        这里输出的是一个字符串，使用Arrays的toString 方法，把传入的参数array,
//        表示的数组，以字符串的形式进行输出!!!
    }
    public static void main6(String[] args) {
        int[] array=new int[]{10,20,30,40,50};
        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);
        System.out.println(array[3]);
        System.out.println(array[4]);
//        System.out.println(array[5]);//err

        //也可以通过[]对数组中的元素进行修改
        array[0]=100;
        System.out.println(array[0]);
    }
    public static void main5(String[] args) {
        int[] array={1,2,3,4,5,6};
        System.out.println(array[5]);//array.sout
    }
    public static void main4(String[] args) {
        boolean[] flg=new boolean[3];//flg:[false,false,false]
//        如果数组中存储元素类型为引用类型，默认值为null
    }
    public static void main3(String[] args) {
        int[] array1;//定义数组
        array1=new int[10];//初始化

        int[]array2;//定义数组
        array2=new int[]{1,2,3,4};//初始化


//        int[] array3={1,2,3};right
//        注意省略格式不可以拆分，否则编译失败
//            err:
//        int[]array3;
//        array3={1,2,3};

        int[] array3={1,2,3,4,5};
        int[] array4=new int[]{1,2,3,4,5};
        int[] array5=new int[5];
    }
    public static void main2(String[] args) {
        int[] array={1,2,3,4,5,6};
        int[] array2=new int[]{1,2,3,4,5,6};//new创建新的对象
        int[]array3=new int[10];//创建一个可以容纳10个int类型的元素的数组
        double[] array4=new double[5];
        String[] array5=new String[3];
//        int[] array=new int[10];
        int[] array6=new int[]{1,2,3,4,5,6};
        double[] array7=new double[]{1.0,2.0,3.0};
        String[] array8=new String[]{"hello","java","!!!"};

    }
    public static void main1(String[] args) {
        int score1=70;
        int score2=80;
        int score3=80;
        int score4=80;
        int score5=80;
        System.out.println(score1);
        System.out.println(score2);
        System.out.println(score3);
        System.out.println(score4);
        System.out.println(score5);
    }
}
